home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1999 March / EnigmA AMIGA RUN 35 (1999)(G.R. Edizioni)(IT)[!][issue 1999-03].iso / earcd / grafica / amhelios / ct_clip.cpp < prev    next >
C/C++ Source or Header  |  1999-01-01  |  6KB  |  197 lines
  1. ////////////////////////////////////////////////////////////
  2. //
  3. //  CT_CLIP.CPP - Cubic Tetrahedron Polygon Clipper Class
  4. //
  5. //  Version:    1.03A
  6. //
  7. //  History:    94/08/23 - Version 1.00A release.
  8. //              94/12/16 - Version 1.01A release.
  9. //              95/02/05 - Version 1.02A release.
  10. //              95/07/21 - Version 1.02B release.
  11. //              95/09/04 - Fixed random vector selection
  12. //                         error in SetView.
  13. //              96/02/14 - Version 1.02C release.
  14. //              96/04/01 - Version 1.03A release.
  15. //
  16. //  Compilers:  Microsoft Visual C/C++ Professional V1.5
  17. //              Borland C++ Version 4.5
  18. //
  19. //  Author:     Ian Ashdown, P.Eng.
  20. //              byHeart Software Limited
  21. //              620 Ballantree Road
  22. //              West Vancouver, B.C.
  23. //              Canada V7S 1W3
  24. //              Tel. (604) 922-6148
  25. //              Fax. (604) 987-7621
  26. //
  27. //  Copyright 1994-1996 byHeart Software Limited
  28. //
  29. //  The following source code has been derived from:
  30. //
  31. //    Ashdown, I. 1994. Radiosity: A Programmer's
  32. //    Perspective. New York, NY: John Wiley & Sons.
  33. //
  34. //  It may be freely copied, redistributed, and/or modified
  35. //  for personal use ONLY, as long as the copyright notice
  36. //  is included with all source code files.
  37. //
  38. ////////////////////////////////////////////////////////////
  39.  
  40. #include "ct_clip.h"
  41.  
  42. CubicClip::CubicClip()  // CubicClip class constructor
  43. {
  44.   Vector4 temp;     // Temporary vector
  45.  
  46.   // Link edge-plane clippers
  47.   pclip = &(clipper[CT_Front]);
  48.   clipper[CT_Front].Add(&(clipper[CT_Left]));
  49.   clipper[CT_Left].Add(&(clipper[CT_Bottom]));
  50.   clipper[CT_Bottom].Add(&(clipper[CT_Diag]));
  51.   clipper[CT_Diag].Add(NULL);
  52.  
  53.   // Set clipper plane normals
  54.  
  55.   temp = Vector4(0.0, 0.0, 1.0, 0.0);
  56.   clipper[CT_Front].SetNormal(temp.Norm());
  57.  
  58.   temp = Vector4(1.0, 0.0, 0.0, 0.0);
  59.   clipper[CT_Left].SetNormal(temp.Norm());
  60.  
  61.   temp = Vector4(0.0, 1.0, 0.0, 0.0);
  62.   clipper[CT_Bottom].SetNormal(temp.Norm());
  63.  
  64.   temp = Vector4(-1.0, -1.0, 0.0, 1.0);
  65.   clipper[CT_Diag].SetNormal(temp.Norm());
  66. }
  67.  
  68. // Choose random cubic tetrahedron orientation
  69. void CubicClip::SetView( Patch3 *ppatch )
  70. {
  71.   double a, b, c;   // Temporary variables
  72.   Vector3 rv;       // Random vector
  73.   Vector3 patch_u;  // Patch view space u-axis vector
  74.   Vector3 patch_v;  // Patch view space v-axis vector
  75.   Vector3 patch_n;  // Patch view space n-axis vector
  76.  
  77.   // Get eye position (cubic tetrahedron center)
  78.   center = ppatch->GetCenter();
  79.  
  80.   patch_n = ppatch->GetNormal();    // Get patch normal
  81.  
  82.   do   // Get valid u-axis vector
  83.   {
  84.     // Select random vector for cubic tetrahedron
  85.     // orientation
  86.     rv = RandomVector();
  87.  
  88.     patch_u = Cross(patch_n, rv);
  89.   }
  90.   while (patch_u.Length() < MIN_VALUE);
  91.  
  92.   patch_u.Norm();                       // Normalize u-axis
  93.   patch_v = Cross(patch_u, patch_n);    // Determine v-axis
  94.  
  95.   // Rotate cubic tetrahedron view space co-ordinate system
  96.   // to align it with respect to patch view space such
  97.   // that:
  98.   //
  99.   //   u = a * patch_u + b * patch_v - c * patch_n
  100.   //   v = b * patch_u + a * patch_v - c * patch_n
  101.   //   n = c * patch_u + c * patch_v - c * patch_n
  102.   //
  103.   // where:
  104.   //
  105.   //   a = 1 / (2 * sqrt(3)) + 1 / 2
  106.   //   b = 1 / (2 * sqrt(3)) - 1 / 2
  107.   //   c = -1 / sqrt(3)
  108.  
  109.   c = -1.0 / sqrt(3.0);
  110.   a = (c * -0.5) + 0.5;
  111.   b = (c * -0.5) - 0.5;
  112.  
  113.   u = a * patch_u + b * patch_v - c * patch_n;
  114.   v = b * patch_u + a * patch_v - c * patch_n;
  115.   n = c * patch_u + c * patch_v - c * patch_n;
  116. }
  117.  
  118. void CubicClip::BuildTransform( Vector3 &nu, Vector3 &nv,
  119.     Vector3 &nn)
  120. {
  121.   Vector3 origin;       // View space origin
  122.  
  123.   origin = Vector3(center);
  124.  
  125.   // Set view transformation matrix
  126.   vtm[0][0] = nu.GetX();
  127.   vtm[0][1] = nu.GetY();
  128.   vtm[0][2] = nu.GetZ();
  129.   vtm[0][3] = -(Dot(origin, nu));
  130.  
  131.   vtm[1][0] = nv.GetX();
  132.   vtm[1][1] = nv.GetY();
  133.   vtm[1][2] = nv.GetZ();
  134.   vtm[1][3] = -(Dot(origin, nv));
  135.  
  136.   vtm[2][0] = nn.GetX();
  137.   vtm[2][1] = nn.GetY();
  138.   vtm[2][2] = nn.GetZ();
  139.   vtm[2][3] = -(Dot(origin, nn));
  140.  
  141.   vtm[3][0] = 0.0;
  142.   vtm[3][1] = 0.0;
  143.   vtm[3][2] = 0.0;
  144.   vtm[3][3] = 1.0;
  145.  
  146.   // Premultiply by translation matrix
  147.   vtm[2][3] -= 1.0;
  148.  
  149.   // Premultiply by perspective transformation matrix
  150.   vtm[3][0] += vtm[2][0];
  151.   vtm[3][1] += vtm[2][1];
  152.   vtm[3][2] += vtm[2][2];
  153.   vtm[3][3] += vtm[2][3];
  154.  
  155.   // Premultiply by normalization matrix
  156.  
  157.   vtm[0][0] = (vtm[0][0] + vtm[3][0]) / 3.0;
  158.   vtm[0][1] = (vtm[0][1] + vtm[3][1]) / 3.0;
  159.   vtm[0][2] = (vtm[0][2] + vtm[3][2]) / 3.0;
  160.   vtm[0][3] = (vtm[0][3] + vtm[3][3]) / 3.0;
  161.  
  162.   vtm[1][0] = (vtm[1][0] + vtm[3][0]) / 3.0;
  163.   vtm[1][1] = (vtm[1][1] + vtm[3][1]) / 3.0;
  164.   vtm[1][2] = (vtm[1][2] + vtm[3][2]) / 3.0;
  165.   vtm[1][3] = (vtm[1][3] + vtm[3][3]) / 3.0;
  166.  
  167.   vtm[2][0] = SN * vtm[2][0] + RN * vtm[3][0];
  168.   vtm[2][1] = SN * vtm[2][1] + RN * vtm[3][1];
  169.   vtm[2][2] = SN * vtm[2][2] + RN * vtm[3][2];
  170.   vtm[2][3] = SN * vtm[2][3] + RN * vtm[3][3];
  171. }
  172.  
  173. // Update cubic tetrahedron view transformation matrix
  174. void CubicClip::UpdateView( int face_id )
  175. {
  176.   Vector3 nu, nv, nn;   // View space co-ordinates
  177.  
  178.   switch (face_id )     // Exchange co-ordinates
  179.   {
  180.     case CT_TopFace:
  181.       nu = -u; nv = -v; nn = n;
  182.       break;
  183.     case CT_RightFace:
  184.       nu = -v; nv = -n; nn = u;
  185.       break;
  186.     case CT_LeftFace:
  187.       nu = -u; nv = -n; nn = v;
  188.       break;
  189.     default:
  190.       break;
  191.   }
  192.   
  193.   // Build new view transformation matrix
  194.   BuildTransform(nu, nv, nn);
  195. }
  196.  
  197.